def load_pruned_obj(obj, _):
-     return obj

     def save_align_devices_hook(pickler, obj):
-         pickler.save_reduce(load_align_devices_hook, (obj.__dict__,), obj=obj)

     def load_align_devices_hook(state):
-         state["execution_device"] = MAP_LOCATION
  ...
-     AlignDevicesHook = None

             if torch.Tensor in copyreg.dispatch_table:
-                 old_dispatch[torch.Tensor] = copyreg.dispatch_table[torch.Tensor]
             copyreg.pickle(torch.Tensor, reduce_empty)

     if span_getter is None:
-         yield doclike[:], None
-         return
     if callable(span_getter):

     if callable(span_getter):
-         yield from span_getter(doclike)
-         return
     for key, span_filter in span_getter.items():

         else:
-             for span, group in candidates:
-                 if span.label_ in span_filter:
-                     yield span, group

     if callable(span_setter):
-         span_setter(doc, matches)
     else:

     if callable(value):
-         return value
     if isinstance(value, str):

             elif isinstance(v, str):
-                 new_value[k] = [v]
             elif isinstance(v, list) and all(isinstance(i, str) for i in v):

     if not verbs:
-         return conjugated_verbs

     else:
-         string = s
     string = string.lower().strip()

         return int(string)
-     except ValueError:
-         parsed = DIGITS_MAPPINGS.get(string, None)
-         return parsed

         if len(other.begins) == 0:
-             return self
         begins = self.unapply(other.begins, side="left")

     if isinstance(label, int):
-         return [span for span in spans if span.label == label]
     else:

             )
-         except RuntimeError as e:
             if "zero total variance" in str(e):  # pragma: no cover

         else:
-             n_trials = compute_n_trials(
                 gpu_hours, compute_time_per_trial(study, ema=True)

     if result is None:
-         result = {}
     if isinstance(x, dict):

         if self.sub_batch_size and self.sub_batch_size[1] == "splits":
-             data = data.batchify(
  ...
-             data = data.map(lambda b: [nlp.collate(sb, device=device) for sb in b])
         elif self.sub_batch_size:

                         raise
-                     except Exception:
  ...
-                         raise

                     ) > grad_max_dev * math.sqrt(grad_var):
-                         spike = True
-                         spikes += 1
                     else:

                     if spike and grad_dev_policy == "clip_mean":
-                         torch.nn.utils.clip_grad_norm_(
                             grad_params, grad_mean, norm_type=2

                     elif spike and grad_dev_policy == "clip_threshold":
-                         torch.nn.utils.clip_grad_norm_(
                             grad_params,

                 if col not in values and col != "step":
-                     row.append("")
                 else:

     def tracker(self):
-         return self.printer

         """
-         env_logging_dir = os.environ.get("AIM_LOGGING_DIR", None)
  ...
-         accelerate.tracking.logger.debug(
             f"Initialized Aim run {self.writer.hash} in project {project_name}"

     def log(self, values: dict, step: Optional[int], **kwargs):
-         values = flatten_dict(values)
-         return super().log(values, step, **kwargs)

     if not hasattr(module, "__file__"):
-         return True
     if module.__file__ is None:

     if module.__file__ is None:
-         return False
     # Hack to avoid copying the full module dict

         getActiveSession = SparkSession.getActiveSession
-     except AttributeError:

                     return re.findall(r"/[^\s]+\.so[^\s]*", f.read())
-             except Exception:
  ...
-             return []

         loaded = loaded_libs()
-     except Exception:
-         return False
     return any(any(k in os.path.basename(p).lower() for k in libs) for p in loaded)

         )
-         method = "spawn"

     if has_hdfs and method == "fork":
-         safe = "forkserver" if "forkserver" in methods else "spawn"
  ...
-         method = safe

                     pass
-             except StopSignal:
-                 pass
             for name, queue in self.consumer_queues(stage):

             if isinstance(docs, StreamSentinel):
-                 self.active_batches[stage].append([None, None, None, docs])
-                 continue
             batch_id = str(hash(tuple(id(x) for x in docs)))[-8:] + "-" + self.uid

                 if out[0].kind == requires_sentinel:
-                     missing_sentinels -= 1
  ...
-                         missing_sentinels = len(self.cpu_worker_names)
                 continue

         def converter(doc):
-             res = results_extractor(doc)
-             return (
                 [{"note_id": doc._.note_id, **row} for row in res]

             if self.reference_mode == "synonym":
-                 embeds = embeds.to(new_lin.weight)
-                 new_lin.weight.data = embeds
             else:

         if not all(keep_bindings):
-             logger.warning(
                 "Some attributes have no labels or values and have been removed:"

         if self.labels is not None and not self.infer_span_setter:
-             return

             if callable(self.target_span_getter):
-                 for span in get_spans(doc, self.target_span_getter):
-                     inferred_labels.add(span.label_)
             else:

     # out: 2 * N * O
-     return (log_A.unsqueeze(-1) + log_B.unsqueeze(-3)).logsumexp(-2)

     # out: 2 * N * O
-     return (log_A.unsqueeze(-1) + log_B.unsqueeze(-3)).max(-2)

         if learnable_transitions:
-             self.transitions = torch.nn.Parameter(
                 torch.zeros_like(forbidden_transitions, dtype=torch.float)

         if learnable_transitions and with_start_end_transitions:
-             self.start_transitions = torch.nn.Parameter(
                 torch.zeros(num_tags, dtype=torch.float)

         if learnable_transitions and with_start_end_transitions:
-             self.end_transitions = torch.nn.Parameter(
                 torch.zeros(num_tags, dtype=torch.float)

         if quantization is not None:
-             kwargs["quantization_config"] = quantization

         if self.cls_token_id is None:
-             [self.cls_token_id] = self.tokenizer.convert_tokens_to_ids(
                 [self.tokenizer.special_tokens_map["bos_token"]]

         if self.sep_token_id is None:
-             [self.sep_token_id] = self.tokenizer.convert_tokens_to_ids(
                 [self.tokenizer.special_tokens_map["eos_token"]]

         return "REPORTED"
-     elif token._.rspeech is False:
-         return "DIRECT"
-     else:
-         return None

     else:
-         return None

     else:
-         return None

 def history_getter(token: Union[Token, Span]) -> Optional[str]:
-     if token._.history is True:
-         return "ATCD"
-     elif token._.history is False:
-         return "CURRENT"
-     else:
-         return None

                 )
-             except ValueError:
  ...
-                 note_datetime = None

                 )
-             except ValueError:
  ...
-                 birth_datetime = None

                         )
-                     except ValueError as e:
-                         absolute_date = None
-                         logger.warning(
                             "In doc {}, the following date {} raises this error: {}. "

     else:
-         return None

     def __str__(self):
-         return self.norm()

             )
-             exclude_unset = skip_defaults

             if not assigned:
-                 continue
             if assigned.get("method_max") is not None:

             else:
-                 method = "Non précisée"

         if x <= 5:
-             return 1

         else:
-             return 3
- 
-     except ValueError:
-         return None

             return int(extracted_score)
-     except ValueError:
-         return None

         for span in spans:
-             span.label_ = "solid_tumor"
  ...
-             yield span

                 if "peripheral" not in span._.assigned.keys():
-                     continue

                 # Mostly FP
-                 continue

             elif self.has_far_complications(span):
-                 span._.status = 2

         if next(iter(self.complication_matcher(context)), None) is not None:
-             return True
         return False

                 # Huge change of FP / Title section
-                 continue

             dfg_value = float(dfg_span.text.replace(",", ".").strip())
-         except ValueError:
-             logger.trace(f"DFG value couldn't be extracted from {dfg_span.text}")
-             return False

             if span._.source == "ischemia":
-                 if "brain" not in span._.assigned.keys():
-                     continue

     def norm(self) -> str:
-         return self.code

     def __str__(self):
-         return self.norm()

         if max_length <= 0 and self.regex is None:
-             yield doc
-             return

         if sections is None:
-             sections = patterns.sections
         sections = dict(sections)

     def __getitem__(self, item: int):
-         assert isinstance(item, int)
-         return [self][item]

     def __eq__(self, other: Any):
-         if isinstance(other, SimpleQuantity):
-             return self.convert_to(other.unit) == other.value
-         return False

         if other.unit == self.unit:
-             return SimpleQuantity(self.value + other.value, self.unit, self.registry)
         return SimpleQuantity(

             return self.convert_to(other_unit)
-         except KeyError:
             raise AttributeError(f"Unit {other_unit} not found")

     def verify(cls, ent):
-         return True

     def __lt__(self, other: Union[SimpleQuantity, "RangeQuantity"]):
-         return max(self.convert_to(other.unit)) < min((part.value for part in other))

             return self.convert_to(other.unit) == other.value
-         return False

     def verify(cls, ent):
-         return True

         if snippet.end != last and doclike.doc[last: snippet.end].text.strip() == "":
-             pseudo.append("w")
         pseudo = "".join(pseudo)

                             if start_line is None:
-                                 continue

                         unit_norm = self.unit_followers[unit_before.label_]
-                 except (KeyError, AttributeError, IndexError):
-                     pass

             ):
-                 ent = doc[unit_text.start: number.end]
             else:

                 dims = self.unit_registry.parse_unit(unit_norm)[0]
-             except KeyError:
-                 continue

                     last._.set(last.label_, new_value)
-                 except (AttributeError, TypeError):
-                     merged.append(ent)
             else:

                     else:
-                         d["month"] = note_datetime.month
                 if self.day is None:

             else:
-                 if self.year is None:
  ...
-                     d["day"] = default_day

                 return dt
-             except ValueError:
-                 return None

         else:
-             return None

         if self.second:
-             norm += f"{self.second:02}s"

         if isinstance(absolute, str):
-             absolute = [absolute]
         if isinstance(relative, str):

         if isinstance(relative, str):
-             relative = [relative]
         if isinstance(duration, str):

         if isinstance(duration, str):
-             relative = [duration]
         if isinstance(false_positive, str):

             if self.merge_mode == "align":
-                 alignments = align_spans(matches, spans, sort_by_overlap=True)
  ...
-                         matches.append(span)

                 if v1.mode == Mode.DURATION:
-                     m1 = Bound.FROM if v2.bound == Bound.UNTIL else Bound.UNTIL
-                     m2 = v2.mode or Bound.FROM
                 elif v2.mode == Mode.DURATION:

         else:
-             self.date_matcher = None

         if not consultation_mention:
-             consultation_mention = []
         elif consultation_mention is True:

             if span is None:
-                 continue
             spans.append(span)

             if result is None:
-                 buffer[i] = ctx
             else:

                     )
-                     buffer[i] = ctx
                 else:

                     if len(in_flight) >= self.max_concurrent_requests:
-                         break
                     i2, d2 = next(ctx_iter)

                     break
-                 messages2 = self.build_prompt(d2)
-                 task_id2 = worker.submit(self._llm_request_coro(messages2))
-                 in_flight[task_id2] = i2
-                 pending_docs[i2] = d2

 def excluded_or_space_getter(t):
-     return t.is_space or t.tag_ == "EXCLUDED"

         if end_lines_model is None:
-             path = build_path(__file__, "base_model.pkl")
- 
-             with open(path, "rb") as inp:
-                 self.model = pickle.load(inp)
         elif isinstance(end_lines_model, str):

                 self.model = pickle.load(inp)
-         elif isinstance(end_lines_model, EndLinesModel):
-             self.model = end_lines_model
         else:

         ):
-             return "ENUMERATION"

         if np.isnan(sigma):
-             sigma = 1

             ):
-                 to_keep = False
-                 break

             # if module is reloaded.
-             existing_func = registry.factories.get(internal_name)
-             if not util.is_same_func(factory_func, existing_func):
                 raise ValueError(

             version = version or pyproject["project"]["version"]
-         except (KeyError, TypeError):
-             version = "0.1.0"
         name = name or pyproject["project"]["name"]

         else:
-             main_package = None
         model_package = snake_case(name.lower())

         )
-         assert attributes is None
-         attributes = kwargs.pop("qualifiers")
     if attributes is None:

     if custom:
-         attr = attr[1:].lower()

             if custom:
-                 token_text = getattr(token._, attr)
             else:

             if last != begin:
-                 logger.warning(
                     "Missed some characters during"

     def __init__(self, ann_file, line):
-         super().__init__(f"File {ann_file}, unrecognized Brat line {line}")

                         )
-                 except Exception:
                     raise Exception(

         if hasattr(data, "collect"):
-             data = data.collect()
         assert isinstance(data, pl.DataFrame)

                 return records
-         except Exception as e:
             raise Exception(f"Cannot read {file}: {e}")

                 elif key == "XPOS":
-                     word.tag_ = value
                 elif key == "FEATS":

         if self.keep_raw_attribute_values:
-             return value
         try:

                 if not attr:
-                     continue
                 if "=" in attr:

             if span is None:
-                 continue
             for k, v in attrs.items():

         if isinstance(value, (bool, int, float)):
-             return repr(value)
         s = str(value)

     if isinstance(converter, type):
-         return converter(**kwargs), {}
     return converter, validate_kwargs(converter, kwargs)

             )
-         except StopIteration:
-             cols = DEFAULT_COLUMNS
             warnings.warn(

         if not line:
-             if doc["words"]:
-                 yield doc
-                 doc = {"words": []}
-             continue
         if line.startswith("#"):

             if hasattr(self, "compiled"):
-                 res = self.compiled(batch)
             else:

         """
-         return self.preprocess(doc)

             else:
-                 yield res
             return

                 if isinstance(batch, StreamSentinel):
-                     yield batch
-                     continue
                 results = []

                 elif op.batch_fn is None:
-                     batch_size = op.size
-                     batch_fn = batchify
                 else:

         if isinstance(obj, DraftPipe):
-             return obj
         elif isinstance(obj, dict):

                 if result is not None:
-                     return result
         elif isinstance(obj, (tuple, list, set)):

                 if result is not None:
-                     return result
         return None

             if name in exclude:
-                 continue
             if name not in components:

         """
-         res = Stream.ensure_stream(docs)
-         res = res.map(functools.partial(self.preprocess, supervision=supervision))
-         return res

         if not isinstance(row.ents, list):
-             continue

             else:
-                 doc.spans[span.label_].append(span)

     if df.note_id.isna().any():
-         df["note_id"] = range(len(df))

         if i > 0:
-             df.term_modifiers += ";"
         df.term_modifiers += ext + "=" + df[ext].astype(str)